home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / shells / tcshsrc.zoo / tcsh / ed.refresh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-25  |  28.6 KB  |  1,173 lines
  1. /* $Header: /home/hyperion/mu/christos/src/sys/tcsh-6.00/RCS/ed.refresh.c,v 3.1 1991/07/15 19:37:24 christos Exp $ */
  2. /*
  3.  * ed.refresh.c: Lower level screen refreshing functions
  4.  */
  5. /*-
  6.  * Copyright (c) 1980, 1991 The Regents of the University of California.
  7.  * All rights reserved.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  *    This product includes software developed by the University of
  20.  *    California, Berkeley and its contributors.
  21.  * 4. Neither the name of the University nor the names of its contributors
  22.  *    may be used to endorse or promote products derived from this software
  23.  *    without specific prior written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  */
  37. #include "config.h"
  38. RCSID("$Id: ed.refresh.c,v 3.1 1991/07/15 19:37:24 christos Exp $")
  39.  
  40. #include "sh.h"
  41. #include "ed.h"
  42. /* #define DEBUG_UPDATE */
  43. /* #define DEBUG_REFRESH */
  44. /* #define DEBUG_LITERAL */
  45.  
  46. /* refresh.c -- refresh the current set of lines on the screen */
  47.  
  48. Char   *litptr[256];
  49. static int vcursor_h, vcursor_v;
  50.  
  51. static    void    Draw             __P((int));
  52. static    void    Vdraw             __P((int));
  53. static    void    Vnewline         __P((void));
  54. static    void    update_line         __P((Char *, Char *, int));
  55. static    void    str_insert        __P((Char *, int, int, Char *, int));
  56. static    void    str_delete        __P((Char *, int, int, int));
  57. static    void    str_cp            __P((Char *, Char *, int));
  58. static    void    PutPlusOne        __P((int));
  59. static    void    cpy_pad_spaces        __P((Char *, Char *, int));
  60. #ifdef DEBUG_UPDATE
  61. static    void    dprintstr        __P((char *, Char *, Char *));
  62. static    void    dprintf            __P((char *, ...));
  63. #endif  /* DEBUG_UPDATE */
  64.  
  65. #ifdef DEBUG_UPDATE
  66. static void
  67. dprintstr(str, f, t)
  68. char *str;
  69. Char *f, *t;
  70. {
  71.     dprintf("%s:\"", str);
  72.     while (f < t)
  73.     dprintf("%c", *f++ & ASCII);
  74.     dprintf("\"\r\n");
  75. } 
  76.  
  77. /* dprintf():
  78.  *    Print to $DEBUGTTY, so that we can test editing on one pty, and 
  79.  *      print debugging stuff on another. Don't interrupt the shell while
  80.  *    debugging cause you'll mangle up the file descriptors!
  81.  */
  82. static void
  83. #if __STDC__
  84. dprintf(char *fmt, ...)
  85. #else
  86. dprintf(va_list)
  87.     va_dcl
  88. #endif /* __STDC__ */
  89. {
  90.     static int fd = -1;
  91.     char *dtty;
  92.  
  93.     if ((dtty = getenv("DEBUGTTY"))) {
  94.     int o;
  95.     va_list va;
  96. #if __STDC__
  97.     va_start(va, fmt);
  98. #else
  99.     char *fmt;
  100.     va_start(va);
  101.     fmt = va_arg(va, char *);
  102. #endif /* __STDC__ */
  103.  
  104.     if (fd == -1)
  105.         fd = open(dtty, O_RDWR);
  106.     o = SHOUT;
  107.     flush();
  108.     SHOUT = fd;
  109.     vprintf(fmt, va);
  110.     va_end(va);
  111.     flush();
  112.     SHOUT = o;
  113.     }
  114. }
  115. #endif  /* DEBUG_UPDATE */
  116.  
  117. static void
  118. Draw(c)                /* draw c, expand tabs, ctl chars */
  119.     register int c;
  120. {
  121.     register Char ch = c & CHAR;
  122.  
  123.     if (Isprint(ch)) {
  124.     Vdraw(c);
  125.     return;
  126.     }
  127.     /* from wolman%crltrx.DEC@decwrl.dec.com (Alec Wolman) */
  128.     if (ch == '\n') {        /* expand the newline     */
  129.     Vdraw('\0');    /* assure end of line     */
  130.     vcursor_h = 0;        /* reset cursor pos     */
  131.     vcursor_v++;
  132.     return;
  133.     }
  134.     if (ch == '\t') {        /* expand the tab      */
  135.     for (;;) {
  136.         Vdraw(' ');
  137.         if ((vcursor_h & 07) == 0)
  138.         break;        /* go until tab stop     */
  139.     }
  140.     }
  141.     else if (Iscntrl(ch)) {
  142.     Vdraw('^');
  143.     if (ch == '\177') {
  144.         Vdraw('?');
  145.     }
  146.     else {
  147.         /* uncontrolify it; works only for iso8859-1 like sets */
  148.         Vdraw((c | 0100));
  149.     }
  150.     }
  151.     else {
  152.     Vdraw('\\');
  153.     Vdraw(((c >> 6) & 7) + '0');
  154.     Vdraw(((c >> 3) & 7) + '0');
  155.     Vdraw((c & 7) + '0');
  156.     }
  157. }
  158.  
  159. static void
  160. Vdraw(c)            /* draw char c onto V lines */
  161.     register int c;
  162. {
  163. #ifdef DEBUG_REFRESH
  164. # ifdef SHORT_STRINGS
  165.     dprintf("Vdrawing %6.6o '%c'\r\n", c, c & ASCII);
  166. # else
  167.     dprintf("Vdrawing %3.3o '%c'\r\n", c, c);
  168. # endif /* SHORT_STRNGS */
  169. #endif  /* DEBUG_REFRESH */
  170.  
  171.     Vdisplay[vcursor_v][vcursor_h] = c;
  172.     vcursor_h++;        /* advance to next place */
  173.     if (vcursor_h >= TermH) {
  174.     Vdisplay[vcursor_v][TermH] = '\0';    /* assure end of line */
  175.     vcursor_h = 0;        /* reset it. */
  176.     vcursor_v++;
  177.     if (vcursor_v >= TermV) {    /* should NEVER happen. */
  178. #ifdef DEBUG_REFRESH
  179.         dprintf("\r\nVdraw: vcursor_v overflow! Vcursor_v == %d > %d\r\n",
  180.             vcursor_v, TermV);
  181.         abort();
  182. #endif /* DEBUG_REFRESH */
  183.     }
  184.     }
  185. }
  186.  
  187. static void
  188. Vnewline()
  189. {
  190.     /* needs work. */
  191. }
  192.  
  193. /*
  194.  *  Refresh()
  195.  *    draws the new virtual screen image from the current input
  196.  *      line, then goes line-by-line changing the real image to the new
  197.  *    virtual image. The routine to re-draw a line can be replaced
  198.  *    easily in hopes of a smarter one being placed there.
  199.  */
  200. static int OldvcV = 0;
  201. void
  202. Refresh()
  203. {
  204.     register int cur_line;
  205.     register Char *cp;
  206.     int     cur_h, cur_v = 0, new_vcv;
  207.     Char    oldgetting;
  208.     int     litnum = 0;
  209.  
  210. #ifdef DEBUG_REFRESH
  211.     dprintf("PromptBuf = :%s:\r\n", short2str(PromptBuf));
  212.     dprintf("InputBuf = :%s:\r\n", short2str(InputBuf));
  213. #endif /* DEBUG_REFRESH */
  214.     oldgetting = GettingInput;
  215.     GettingInput = 0;        /* avoid re-entrance via SIGWINCH */
  216.  
  217.     /* reset the Vdraw cursor */
  218.     vcursor_h = 0;
  219.     vcursor_v = 0;
  220.  
  221.     /* draw prompt, we know it's ASCIZ */
  222.     for (cp = PromptBuf; *cp; cp++) {
  223.     if (*cp & LITERAL) {
  224.         if (litnum < (sizeof(litptr) / sizeof(litptr[0]))) {
  225.         litptr[litnum] = cp;
  226. #ifdef DEBUG_LITERAL
  227.         dprintf("litnum = %d, litptr = %x:\r\n",
  228.             litnum, litptr[litnum]);
  229. #endif /* DEBUG_LITERAL */
  230.         }
  231.         while (*cp & LITERAL)
  232.         cp++;
  233.         if (*cp)
  234.         Vdraw(litnum++ | LITERAL);
  235.         else {
  236.         /*
  237.          * XXX: This is a bug, we lose the last literal, if it is not
  238.          * followed by a normal character, but it is too hard to fix
  239.          */
  240.         break;
  241.         }
  242.     }
  243.     else
  244.         Draw(*cp);
  245.     }
  246.     cur_h = -1;            /* set flag in case I'm not set */
  247.  
  248.     /* draw the current input buffer */
  249.     for (cp = InputBuf; (cp < LastChar); cp++) {
  250.     if (cp == Cursor) {
  251.         cur_h = vcursor_h;    /* save for later */
  252.         cur_v = vcursor_v;
  253.     }
  254.     Draw(*cp);
  255.     }
  256.  
  257.     /* to next line and draw the current search prompt if searching */
  258.     if (DoingSearch) {
  259.     Vnewline();
  260.     for (cp = SearchPrompt; *cp; cp++)
  261.         Draw(*cp);
  262.     for (cp = InputBuf; (cp < LastChar); cp++) {
  263.         if (cp == Cursor) {
  264.         cur_h = vcursor_h;    /* save for later */
  265.         cur_v = vcursor_v;
  266.         }
  267.         Draw(*cp);
  268.     }
  269.     }
  270.  
  271.     if (cur_h == -1) {        /* if I havn't been set yet, I'm at the end */
  272.     cur_h = vcursor_h;
  273.     cur_v = vcursor_v;
  274.     }
  275.     new_vcv = vcursor_v;    /* must be done BEFORE the NUL is written */
  276.     Vdraw('\0');        /* put NUL on end */
  277.  
  278. #ifdef DEBUG_REFRESH
  279.     dprintf("TermH=%d, vcur_h=%d, vcur_v=%d, Vdisplay[0]=\r\n:%80.80s:\r\n",
  280.         TermH, vcursor_h, vcursor_v, short2str(Vdisplay[0]));
  281. #endif /* DEBUG_REFRESH */
  282.  
  283. #ifdef DEBUG_UPDATE
  284.     dprintf("updating %d lines.\r\n", new_vcv);
  285. #endif  /* DEBUG_UPDATE */
  286.     for (cur_line = 0; cur_line <= new_vcv; cur_line++) {
  287.     /* NOTE THAT update_line MAY CHANGE Display[cur_line] */
  288.     update_line(Display[cur_line], Vdisplay[cur_line], cur_line);
  289.  
  290.     /*
  291.      * Copy the new line to be the current one, and pad out with spaces
  292.      * to the full width of the terminal so that if we try moving the
  293.      * cursor by writing the character that is at the end of the
  294.      * screen line, it won't be a NUL or some old leftover stuff.
  295.      */
  296.     cpy_pad_spaces(Display[cur_line], Vdisplay[cur_line], TermH);
  297. #ifdef notdef
  298.     (void) Strncpy(Display[cur_line], Vdisplay[cur_line], TermH);
  299.     Display[cur_line][TermH] = '\0';    /* just in case */
  300. #endif
  301.     }
  302. #ifdef DEBUG_REFRESH
  303.     dprintf("\r\nvcursor_v = %d, OldvcV = %d, cur_line = %d\r\n",
  304.         vcursor_v, OldvcV, cur_line);
  305. #endif /* DEBUG_REFRESH */
  306.     if (OldvcV > new_vcv) {
  307.     for (; cur_line <= OldvcV; cur_line++) {
  308.         MoveToLine(cur_line);
  309.         MoveToChar(0);
  310.         ClearEOL(Strlen(Display[cur_line]));
  311. #ifdef DEBUG_REFRESH
  312.         so_write(str2short("C\b"), 2);
  313. #endif /* DEBUG_REFRESH */
  314.         *Display[cur_line] = '\0';
  315.     }
  316.     }
  317.     OldvcV = new_vcv;        /* set for next time */
  318. #ifdef DEBUG_REFRESH
  319.     dprintf("\r\nCursorH = %d, CursorV = %d, cur_h = %d, cur_v = %d\r\n",
  320.         CursorH, CursorV, cur_h, cur_v);
  321. #endif /* DEBUG_REFRESH */
  322.     MoveToLine(cur_v);        /* go to where the cursor is */
  323.     MoveToChar(cur_h);
  324.     SetAttributes(0);        /* Clear all attributes */
  325.     flush();            /* send the output... */
  326.     GettingInput = oldgetting;    /* reset to old value */
  327. }
  328.  
  329. #ifdef notdef
  330. GotoBottom()
  331. {                /* used to go to last used screen line */
  332.     MoveToLine(OldvcV);
  333. }
  334.  
  335. #endif 
  336.  
  337. void
  338. PastBottom()
  339. {                /* used to go to last used screen line */
  340.     MoveToLine(OldvcV);
  341.     (void) putraw('\r');
  342.     (void) putraw('\n');
  343.     ClearDisp();
  344.     flush();
  345. }
  346.  
  347.  
  348. /* insert num characters of s into d (in front of the character) at dat,
  349.    maximum length of d is dlen */
  350. static void
  351. str_insert(d, dat, dlen, s, num)
  352.     register Char *d;
  353.     register int dat, dlen;
  354.     register Char *s;
  355.     register int num;
  356. {
  357.     register Char *a, *b;
  358.  
  359.     if (num <= 0)
  360.     return;
  361.     if (num > dlen - dat)
  362.     num = dlen - dat;
  363.  
  364. #ifdef DEBUG_REFRESH
  365.     dprintf("str_insert() starting: %d at %d max %d, d == \"%s\"\n",
  366.         num, dat, dlen, short2str(d));
  367.     dprintf("s == \"%s\"n", short2str(s));
  368. #endif /* DEBUG_REFRESH */
  369.  
  370.     /* open up the space for num chars */
  371.     if (num > 0) {
  372.     b = d + dlen - 1;
  373.     a = b - num;
  374.     while (a >= &d[dat])
  375.         *b-- = *a--;
  376.     d[dlen] = '\0';        /* just in case */
  377.     }
  378. #ifdef DEBUG_REFRESH
  379.     dprintf("str_insert() after insert: %d at %d max %d, d == \"%s\"\n",
  380.         num, dat, dlen, short2str(d));
  381.     dprintf("s == \"%s\"n", short2str(s));
  382. #endif /* DEBUG_REFRESH */
  383.  
  384.     /* copy the characters */
  385.     for (a = d + dat; (a < d + dlen) && (num > 0); num--)
  386.     *a++ = *s++;
  387.  
  388. #ifdef DEBUG_REFRESH
  389.     dprintf("str_insert() after copy: %d at %d max %d, d == \"%s\"\n",
  390.         num, dat, dlen, d, short2str(s));
  391.     dprintf("s == \"%s\"n", short2str(s));
  392. #endif /* DEBUG_REFRESH */
  393. }
  394.  
  395. /* delete num characters d at dat, maximum length of d is dlen */
  396. static void
  397. str_delete(d, dat, dlen, num)
  398.     register Char *d;
  399.     register int dat, dlen, num;
  400. {
  401.     register Char *a, *b;
  402.  
  403.     if (num <= 0)
  404.     return;
  405.     if (dat + num >= dlen) {
  406.     d[dat] = '\0';
  407.     return;
  408.     }
  409.  
  410. #ifdef DEBUG_REFRESH
  411.     dprintf("str_delete() starting: %d at %d max %d, d == \"%s\"\n",
  412.         num, dat, dlen, short2str(d));
  413. #endif /* DEBUG_REFRESH */
  414.  
  415.     /* open up the space for num chars */
  416.     if (num > 0) {
  417.     b = d + dat;
  418.     a = b + num;
  419.     while (a < &d[dlen])
  420.         *b++ = *a++;
  421.     d[dlen] = '\0';        /* just in case */
  422.     }
  423. #ifdef DEBUG_REFRESH
  424.     dprintf("str_delete() after delete: %d at %d max %d, d == \"%s\"\n",
  425.         num, dat, dlen, short2str(d));
  426. #endif /* DEBUG_REFRESH */
  427. }
  428.  
  429. static void
  430. str_cp(a, b, n)
  431.     register Char *a, *b;
  432.     register int n;
  433. {
  434.     while (n-- && *b)
  435.     *a++ = *b++;
  436. }
  437.  
  438.  
  439.  
  440. /* ****************************************************************
  441.     update_line() is based on finding the middle difference of each line
  442.     on the screen; vis:
  443.  
  444.                  /old first difference
  445.     /beginning of line   |              /old last same       /old EOL
  446.     v             v              v                    v
  447. old:    eddie> Oh, my little gruntle-buggy is to me, as lurgid as
  448. new:    eddie> Oh, my little buggy says to me, as lurgid as
  449.     ^             ^        ^               ^
  450.     \beginning of line   |        \new last same       \new end of line
  451.                  \new first difference
  452.  
  453.     all are character pointers for the sake of speed.  Special cases for
  454.     no differences, as well as for end of line additions must be handled.
  455. **************************************************************** */
  456.  
  457. /* Minimum at which doing an insert it "worth it".  This should be about
  458.  * half the "cost" of going into insert mode, inserting a character, and
  459.  * going back out.  This should really be calculated from the termcap
  460.  * data...  For the moment, a good number for ANSI terminals.
  461.  */
  462. #define MIN_END_KEEP    4
  463.  
  464. static void            /* could be changed to make it smarter */
  465. update_line(old, new, cur_line)
  466.     register Char *old, *new;
  467.     int     cur_line;
  468. {
  469.     register Char *o, *n, *p, c;
  470.     Char   *ofd, *ols, *oe, *nfd, *nls, *ne;
  471.     Char   *osb, *ose, *nsb, *nse;
  472.     int     fx, sx;
  473.  
  474.     /*
  475.      * find first diff
  476.      */
  477.     for (o = old, n = new; *o && (*o == *n); o++, n++);
  478.     ofd = o;
  479.     nfd = n;
  480.  
  481.     /*
  482.      * Find the end of both old and new
  483.      */
  484.     while (*o)
  485.     o++;
  486.     /* 
  487.      * Remove any trailing blanks off of the end, being careful not to
  488.      * back up past the beginning.
  489.      */
  490.     while (ofd < o) {
  491.     if (o[-1] != ' ')
  492.         break;
  493.     o--;
  494.     }
  495.     oe = o;
  496.     *oe = (Char) 0;
  497.   
  498.     while (*n)
  499.     n++;
  500.  
  501.     /* remove blanks from end of new */
  502.     while (nfd < n) {
  503.     if (n[-1] != ' ')
  504.         break;
  505.     n--;
  506.     }
  507.     ne = n;
  508.     *ne = (Char) 0;
  509.   
  510.     /*
  511.      * if no diff, continue to next line of redraw
  512.      */
  513.     if (*ofd == '\0' && *nfd == '\0') {
  514. #ifdef DEBUG_UPDATE
  515.     dprintf("no difference.\r\n");
  516. #endif /* DEBUG_UPDATE */
  517.     return;
  518.     }
  519.  
  520.     /*
  521.      * find last same pointer
  522.      */
  523.     while ((o > ofd) && (n > nfd) && (*--o == *--n));
  524.     ols = ++o;
  525.     nls = ++n;
  526.  
  527.     /*
  528.      * find same begining and same end
  529.      */
  530.     osb = ols;
  531.     nsb = nls;
  532.     ose = ols;
  533.     nse = nls;
  534.  
  535.     /*
  536.      * case 1: insert: scan from nfd to nls looking for *ofd
  537.      */
  538.     if (*ofd) {
  539.     for (c = *ofd, n = nfd; n < nls; n++) {
  540.         if (c == *n) {
  541.         for (o = ofd, p = n; p < nls && o < ols && *o == *p; o++, p++);
  542.         /*
  543.          * if the new match is longer and it's worth keeping, then we
  544.          * take it
  545.          */
  546.         if (((nse - nsb) < (p - n)) && (2 * (p - n) > n - nfd)) {
  547.             nsb = n;
  548.             nse = p;
  549.             osb = ofd;
  550.             ose = o;
  551.         }
  552.         }
  553.     }
  554.     }
  555.  
  556.     /*
  557.      * case 2: delete: scan from ofd to ols looking for *nfd
  558.      */
  559.     if (*nfd) {
  560.     for (c = *nfd, o = ofd; o < ols; o++) {
  561.         if (c == *o) {
  562.         for (n = nfd, p = o; p < ols && n < nls && *p == *n; p++, n++);
  563.         /*
  564.          * if the new match is longer and it's worth keeping, then we
  565.          * take it
  566.          */
  567.         if (((ose - osb) < (p - o)) && (2 * (p - o) > o - ofd)) {
  568.             nsb = nfd;
  569.             nse = n;
  570.             osb = o;
  571.             ose = p;
  572.         }
  573.         }
  574.     }
  575.     }
  576. #ifdef notdef
  577.     /*
  578.      * If `last same' is before `same end' re-adjust
  579.      */
  580.     if (ols < ose)
  581.     ols = ose;
  582.     if (nls < nse)
  583.     nls = nse;
  584. #endif
  585.  
  586.     /*
  587.      * Pragmatics I: If old trailing whitespace or not enough characters to
  588.      * save to be worth it, then don't save the last same info.
  589.      */
  590.     if ((oe - ols) < MIN_END_KEEP) {
  591.     ols = oe;
  592.     nls = ne;
  593.     }
  594.  
  595.     /*
  596.      * Pragmatics II: if the terminal isn't smart enough, make the data dumber
  597.      * so the smart update doesn't try anything fancy
  598.      */
  599.  
  600.     /*
  601.      * fx is the number of characters we need to insert/delete: in the
  602.      * beginning to bring the two same begins together
  603.      */
  604.     fx = (nsb - nfd) - (osb - ofd);
  605.     /*
  606.      * sx is the number of characters we need to insert/delete: in the end to
  607.      * bring the two same last parts together
  608.      */
  609.     sx = (nls - nse) - (ols - ose);
  610.  
  611.     if (!T_CanIns) {
  612.     if (fx > 0) {
  613.         osb = ols;
  614.         ose = ols;
  615.         nsb = nls;
  616.         nse = nls;
  617.     }
  618.     if (sx > 0) {
  619.         ols = oe;
  620.         nls = ne;
  621.     }
  622.     if ((ols - ofd) < (nls - nfd)) {
  623.         ols = oe;
  624.         nls = ne;
  625.     }
  626.     }
  627.     if (!T_CanDel) {
  628.     if (fx < 0) {
  629.         osb = ols;
  630.         ose = ols;
  631.         nsb = nls;
  632.         nse = nls;
  633.     }
  634.     if (sx < 0) {
  635.         ols = oe;
  636.         nls = ne;
  637.     }
  638.     if ((ols - ofd) > (nls - nfd)) {
  639.         ols = oe;
  640.         nls = ne;
  641.     }
  642.     }
  643.  
  644.     /*
  645.      * Pragmatics III: make sure the middle shifted pointers are correct if
  646.      * they don't point to anything (we may have moved ols or nls).
  647.      */
  648.     /* if the change isn't worth it, don't bother */
  649.     /* was: if (osb == ose) */
  650.     if ((ose - osb) < MIN_END_KEEP) {
  651.     osb = ols;
  652.     ose = ols;
  653.     nsb = nls;
  654.     nse = nls;
  655.     }
  656.  
  657.     /*
  658.      * Now that we are done with pragmatics we recompute fx, sx
  659.      */
  660.     fx = (nsb - nfd) - (osb - ofd);
  661.     sx = (nls - nse) - (ols - ose);
  662.  
  663. #ifdef DEBUG_UPDATE
  664.     dprintf("\n");
  665.     dprintf("ofd %d, osb %d, ose %d, ols %d, oe %d\n",
  666.         ofd - old, osb - old, ose - old, ols - old, oe - old);
  667.     dprintf("nfd %d, nsb %d, nse %d, nls %d, ne %d\n",
  668.         nfd - new, nsb - new, nse - new, nls - new, ne - new);
  669.     dprintf("xxx-xxx:\"00000000001111111111222222222233333333334\"\r\n");
  670.     dprintf("xxx-xxx:\"01234567890123456789012345678901234567890\"\r\n");
  671.     dprintstr("old- oe", old, oe);
  672.     dprintstr("new- ne", new, ne);
  673.     dprintstr("old-ofd", old, ofd);
  674.     dprintstr("new-nfd", new, nfd);
  675.     dprintstr("ofd-osb", ofd, osb);
  676.     dprintstr("nfd-nsb", nfd, nsb);
  677.     dprintstr("osb-ose", osb, ose);
  678.     dprintstr("nsb-nse", nsb, nse);
  679.     dprintstr("ose-ols", ose, ols);
  680.     dprintstr("nse-nls", nse, nls);
  681.     dprintstr("ols- oe", ols, oe);
  682.     dprintstr("nls- ne", nls, ne);
  683. #endif /* DEBUG_UPDATE */
  684.  
  685.     /*
  686.      * CursorV to this line cur_line MUST be in this routine so that if we
  687.      * don't have to change the line, we don't move to it. CursorH to first
  688.      * diff char
  689.      */
  690.     MoveToLine(cur_line);
  691.  
  692.     /*
  693.      * at this point we have something like this:
  694.      * 
  695.      * /old                  /ofd    /osb               /ose    /ols     /oe
  696.      * v.....................v       v..................v       v........v
  697.      * eddie> Oh, my fredded gruntle-buggy is to me, as foo var lurgid as
  698.      * eddie> Oh, my fredded quiux buggy is to me, as gruntle-lurgid as
  699.      * ^.....................^     ^..................^       ^........^ 
  700.      * \new                  \nfd  \nsb               \nse     \nls    \ne
  701.      * 
  702.      * fx is the difference in length between the the chars between nfd and
  703.      * nsb, and the chars between ofd and osb, and is thus the number of
  704.      * characters to delete if < 0 (new is shorter than old, as above),
  705.      * or insert (new is longer than short).
  706.      *
  707.      * sx is the same for the second differences.
  708.      */
  709.  
  710.     /*
  711.      * if we have a net insert on the first difference, AND inserting the net
  712.      * amount ((nsb-nfd) - (osb-ofd)) won't push the last useful character
  713.      * (which is ne if nls != ne, otherwise is nse) off the edge of the screen
  714.      * (TermH) else we do the deletes first so that we keep everything we need
  715.      * to.
  716.      */
  717.  
  718.     /*
  719.      * if the last same is the same like the end, there is no last same part,
  720.      * otherwise we want to keep the last same part set p to the last useful
  721.      * old character
  722.      */
  723.     p = (ols != oe) ? oe : ose;
  724.  
  725.     /*
  726.      * if (There is a diffence in the beginning) && (we need to insert
  727.      * characters) && (the number of characters to insert is less than the term
  728.      * width) We need to do an insert! else if (we need to delete characters)
  729.      * We need to delete characters! else No insert or delete
  730.      */
  731.     if ((nsb != nfd) && fx > 0 && ((p - old) + fx <= TermH)) {
  732. #ifdef DEBUG_UPDATE
  733.     dprintf("first diff insert at %d...\r\n", nfd - new);
  734. #endif  /* DEBUG_UPDATE */
  735.     /*
  736.      * Move to the first char to insert, where the first diff is.
  737.      */
  738.     MoveToChar(nfd - new);
  739.     /*
  740.      * Check if we have stuff to keep at end
  741.      */
  742.     if (nsb != ne) {
  743. #ifdef DEBUG_UPDATE
  744.         dprintf("with stuff to keep at end\r\n");
  745. #endif  /* DEBUG_UPDATE */
  746.         /*
  747.          * insert fx chars of new starting at nfd
  748.          */
  749.         if (fx > 0) {
  750. #ifdef DEBUG_UPDATE
  751.         if (!T_CanIns)
  752.             dprintf("   ERROR: cannot insert in early first diff\n");
  753. #endif  /* DEBUG_UPDATE */
  754.         Insert_write(nfd, fx);
  755.         str_insert(old, ofd - old, TermH, nfd, fx);
  756.         }
  757.         /*
  758.          * write (nsb-nfd) - fx chars of new starting at (nfd + fx)
  759.          */
  760.         so_write(nfd + fx, (nsb - nfd) - fx);
  761.         str_cp(ofd + fx, nfd + fx, (nsb - nfd) - fx);
  762.     }
  763.     else {
  764. #ifdef DEBUG_UPDATE
  765.         dprintf("without anything to save\r\n");
  766. #endif  /* DEBUG_UPDATE */
  767.         so_write(nfd, (nsb - nfd));
  768.         str_cp(ofd, nfd, (nsb - nfd));
  769.         /*
  770.          * Done
  771.          */
  772.         return;
  773.     }
  774.     }
  775.     else if (fx < 0) {
  776. #ifdef DEBUG_UPDATE
  777.     dprintf("first diff delete at %d...\r\n", ofd - old);
  778. #endif  /* DEBUG_UPDATE */
  779.     /*
  780.      * move to the first char to delete where the first diff is
  781.      */
  782.     MoveToChar(ofd - old);
  783.     /*
  784.      * Check if we have stuff to save
  785.      */
  786.     if (osb != oe) {
  787. #ifdef DEBUG_UPDATE
  788.         dprintf("with stuff to save at end\r\n");
  789. #endif  /* DEBUG_UPDATE */
  790.         /*
  791.          * fx is less than zero *always* here but we check for code
  792.          * symmetry
  793.          */
  794.         if (fx < 0) {
  795. #ifdef DEBUG_UPDATE
  796.         if (!T_CanDel)
  797.             dprintf("   ERROR: cannot delete in first diff\n");
  798. #endif /* DEBUG_UPDATE */
  799.         DeleteChars(-fx);
  800.         str_delete(old, ofd - old, TermH, -fx);
  801.         }
  802.         /*
  803.          * write (nsb-nfd) chars of new starting at nfd
  804.          */
  805.         so_write(nfd, (nsb - nfd));
  806.         str_cp(ofd, nfd, (nsb - nfd));
  807.  
  808.     }
  809.     else {
  810. #ifdef DEBUG_UPDATE
  811.         dprintf("but with nothing left to save\r\n");
  812. #endif  /* DEBUG_UPDATE */
  813.         /*
  814.          * write (nsb-nfd) chars of new starting at nfd
  815.          */
  816.         so_write(nfd, (nsb - nfd));
  817. #ifdef DEBUG_REFRESH
  818.         dprintf("cleareol %d\n", (oe - old) - (ne - new));
  819. #endif  /* DEBUG_UPDATE */
  820.         ClearEOL((oe - old) - (ne - new));
  821.         /*
  822.          * Done
  823.          */
  824.         return;
  825.     }
  826.     }
  827.     else
  828.     fx = 0;
  829.  
  830.     if (sx < 0) {
  831. #ifdef DEBUG_UPDATE
  832.     dprintf("second diff delete at %d...\r\n", (ose - old) + fx);
  833. #endif  /* DEBUG_UPDATE */
  834.     /*
  835.      * Check if we have stuff to delete
  836.      */
  837.     /*
  838.      * fx is the number of characters inserted (+) or deleted (-)
  839.      */
  840.  
  841.     MoveToChar((ose - old) + fx);
  842.     /*
  843.      * Check if we have stuff to save
  844.      */
  845.     if (ols != oe) {
  846. #ifdef DEBUG_UPDATE
  847.         dprintf("with stuff to save at end\r\n");
  848. #endif  /* DEBUG_UPDATE */
  849.         /*
  850.          * Again a duplicate test.
  851.          */
  852.         if (sx < 0) {
  853. #ifdef DEBUG_UPDATE
  854.         if (!T_CanDel)
  855.             dprintf("   ERROR: cannot delete in second diff\n");
  856. #endif  /* DEBUG_UPDATE */
  857.         DeleteChars(-sx);
  858.         }
  859.  
  860.         /*
  861.          * write (nls-nse) chars of new starting at nse
  862.          */
  863.         so_write(nse, (nls - nse));
  864.     }
  865.     else {
  866. #ifdef DEBUG_UPDATE
  867.         dprintf("but with nothing left to save\r\n");
  868. #endif /* DEBUG_UPDATE */
  869.         so_write(nse, (nls - nse));
  870. #ifdef DEBUG_REFRESH
  871.         dprintf("cleareol %d\n", (oe - old) - (ne - new));
  872. #endif /* DEBUG_UPDATE */
  873.         ClearEOL((oe - old) - (ne - new));
  874.     }
  875.     }
  876.  
  877.     /*
  878.      * if we have a first insert AND WE HAVEN'T ALREADY DONE IT...
  879.      */
  880.     if ((nsb != nfd) && (osb - ofd) <= (nsb - nfd) && (fx == 0)) {
  881. #ifdef DEBUG_UPDATE
  882.     dprintf("late first diff insert at %d...\r\n", nfd - new);
  883. #endif /* DEBUG_UPDATE */
  884.  
  885.     MoveToChar(nfd - new);
  886.     /*
  887.      * Check if we have stuff to keep at the end
  888.      */
  889.     if (nsb != ne) {
  890. #ifdef DEBUG_UPDATE
  891.         dprintf("with stuff to keep at end\r\n");
  892. #endif /* DEBUG_UPDATE */
  893.         /* 
  894.          * We have to recalculate fx here because we set it
  895.          * to zero above as a flag saying that we hadn't done
  896.          * an early first insert.
  897.          */
  898.         fx = (nsb - nfd) - (osb - ofd);
  899.         if (fx > 0) {
  900.         /*
  901.          * insert fx chars of new starting at nfd
  902.          */
  903. #ifdef DEBUG_UPDATE
  904.         if (!T_CanIns)
  905.             dprintf("   ERROR: cannot insert in late first diff\n");
  906. #endif /* DEBUG_UPDATE */
  907.         Insert_write(nfd, fx);
  908.         str_insert(old, ofd - old, TermH, nfd, fx);
  909.         }
  910.  
  911.         /*
  912.          * write (nsb-nfd) - fx chars of new starting at (nfd + fx)
  913.          */
  914.         so_write(nfd + fx, (nsb - nfd) - fx);
  915.         str_cp(ofd + fx, nfd + fx, (nsb - nfd) - fx);
  916.     }
  917.     else {
  918. #ifdef DEBUG_UPDATE
  919.         dprintf("without anything to save\r\n");
  920. #endif /* DEBUG_UPDATE */
  921.         so_write(nfd, (nsb - nfd));
  922.         str_cp(ofd, nfd, (nsb - nfd));
  923.     }
  924.     }
  925.  
  926.     /*
  927.      * line is now NEW up to nse
  928.      */
  929.     if (sx >= 0) {
  930. #ifdef DEBUG_UPDATE
  931.     dprintf("second diff insert at %d...\r\n", nse - new);
  932. #endif /* DEBUG_UPDATE */
  933.     MoveToChar(nse - new);
  934.     if (ols != oe) {
  935. #ifdef DEBUG_UPDATE
  936.         dprintf("with stuff to keep at end\r\n");
  937. #endif /* DEBUG_UPDATE */
  938.         if (sx > 0) {
  939.         /* insert sx chars of new starting at nse */
  940. #ifdef DEBUG_UPDATE
  941.         if (!T_CanIns)
  942.             dprintf("   ERROR: cannot insert in second diff\n");
  943. #endif /* DEBUG_UPDATE */
  944.         Insert_write(nse, sx);
  945.         }
  946.  
  947.         /*
  948.          * write (nls-nse) - sx chars of new starting at (nse + sx)
  949.          */
  950.         so_write(nse + sx, (nls - nse) - sx);
  951.     }
  952.     else {
  953. #ifdef DEBUG_UPDATE
  954.         dprintf("without anything to save\r\n");
  955. #endif /* DEBUG_UPDATE */
  956.         so_write(nse, (nls - nse));
  957.  
  958.         /*
  959.              * No need to do a clear-to-end here because we were doing
  960.          * a second insert, so we will have over written all of the
  961.          * old string.
  962.          */
  963.     }
  964.     }
  965. #ifdef DEBUG_UPDATE
  966.     dprintf("done.\r\n");
  967. #endif /* DEBUG_UPDATE */
  968. }
  969.  
  970.  
  971. static void
  972. cpy_pad_spaces(dst, src, width)
  973.     register Char *dst, *src;
  974.     register int width;
  975. {
  976.     register int i;
  977.  
  978.     for (i = 0; i < width; i++) {
  979.     if (*src == (Char) 0)
  980.         break;
  981.     *dst++ = *src++;
  982.     }
  983.  
  984.     while (i < width) {
  985.     *dst++ = ' ';
  986.     i++;
  987.     }
  988.     *dst = (Char) 0;
  989. }
  990.  
  991. void
  992. RefCursor()
  993. {                /* only move to new cursor pos */
  994.     register Char *cp, c;
  995.     register int h, th, v;
  996.  
  997.     if (DoingSearch) {
  998.     Refresh();
  999.     return;
  1000.     }
  1001.  
  1002.     /* first we must find where the cursor is... */
  1003.     h = 0;
  1004.     v = 0;
  1005.     th = TermH;            /* optimize for speed */
  1006.  
  1007.     for (cp = PromptBuf; *cp; cp++) {    /* do prompt */
  1008.     if (*cp & LITERAL)
  1009.         continue;
  1010.     c = *cp & CHAR;        /* extra speed plus strip the inverse */
  1011.     h++;            /* all chars at least this long */
  1012.  
  1013.     /* from wolman%crltrx.DEC@decwrl.dec.com (Alec Wolman) */
  1014.     /* lets handle newline as part of the prompt */
  1015.  
  1016.     if (c == '\n') {
  1017.         h = 0;
  1018.         v++;
  1019.     }
  1020.     else {
  1021.         if (c == '\t') {    /* if a tab, to next tab stop */
  1022.         while (h & 07) {
  1023.             h++;
  1024.         }
  1025.         }
  1026.         else if (Iscntrl(c)) {    /* if control char */
  1027.         h++;
  1028.         if (h > th) {    /* if overflow, compensate */
  1029.             h = 1;
  1030.             v++;
  1031.         }
  1032.         }
  1033.         else if (!Isprint(c)) {
  1034.         h += 3;
  1035.         if (h > th) {    /* if overflow, compensate */
  1036.             h = h - th;
  1037.             v++;
  1038.         }
  1039.         }
  1040.     }
  1041.  
  1042.     if (h >= th) {        /* check, extra long tabs picked up here also */
  1043.         h = 0;
  1044.         v++;
  1045.     }
  1046.     }
  1047.  
  1048.     for (cp = InputBuf; cp < Cursor; cp++) {    /* do input buffer to Cursor */
  1049.     c = *cp & CHAR;        /* extra speed plus strip the inverse */
  1050.     h++;            /* all chars at least this long */
  1051.  
  1052.     if (c == '\n') {    /* handle newline in data part too */
  1053.         h = 0;
  1054.         v++;
  1055.     }
  1056.     else {
  1057.         if (c == '\t') {    /* if a tab, to next tab stop */
  1058.         while (h & 07) {
  1059.             h++;
  1060.         }
  1061.         }
  1062.         else if (Iscntrl(c)) {    /* if control char */
  1063.         h++;
  1064.         if (h > th) {    /* if overflow, compensate */
  1065.             h = 1;
  1066.             v++;
  1067.         }
  1068.         }
  1069.         else if (!Isprint(c)) {
  1070.         h += 3;
  1071.         if (h > th) {    /* if overflow, compensate */
  1072.             h = h - th;
  1073.             v++;
  1074.         }
  1075.         }
  1076.     }
  1077.  
  1078.     if (h >= th) {        /* check, extra long tabs picked up here also */
  1079.         h = 0;
  1080.         v++;
  1081.     }
  1082.     }
  1083.  
  1084.     /* now go there */
  1085.     MoveToLine(v);
  1086.     MoveToChar(h);
  1087.     flush();
  1088. }
  1089.  
  1090. static void
  1091. PutPlusOne(c)
  1092.     int    c;
  1093. {
  1094.     (void) putraw(c);
  1095.     Display[CursorV][CursorH++] = c;
  1096.     if (CursorH >= TermH) {    /* if we must overflow */
  1097.     CursorH = 0;
  1098.     CursorV++;
  1099.     OldvcV++;
  1100.     (void) putraw('\r');
  1101.     (void) putraw('\n');
  1102.     }
  1103. }
  1104.  
  1105. void
  1106. RefPlusOne()
  1107. {                /* we added just one char, handle it fast *//* a
  1108.                  * ssumes that screen cursor == real cursor */
  1109.     register Char c, mc;
  1110.  
  1111.     c = Cursor[-1] & CHAR;    /* the char we just added */
  1112.  
  1113.     if (c == '\t' || Cursor != LastChar) {
  1114.     Refresh();        /* too hard to handle */
  1115.     return;
  1116.     }                /* else (only do at end of line, no TAB) */
  1117.  
  1118.     if (DoingSearch) {
  1119.     Refresh();
  1120.     return;
  1121.     }
  1122.  
  1123.     if (Iscntrl(c)) {        /* if control char, do caret */
  1124.     mc = (c == '\177') ? '?' : (c | 0100);
  1125.     PutPlusOne('^');
  1126.     PutPlusOne(mc);
  1127.     }
  1128.     else if (Isprint(c)) {    /* normal char */
  1129.     PutPlusOne(c);
  1130.     }
  1131.     else {
  1132.     PutPlusOne('\\');
  1133.     PutPlusOne(((c >> 6) & 7) + '0');
  1134.     PutPlusOne(((c >> 3) & 7) + '0');
  1135.     PutPlusOne((c & 7) + '0');
  1136.     }
  1137.     flush();
  1138. }
  1139.  
  1140. /* clear the screen buffers so that new new prompt starts fresh. */
  1141.  
  1142. void
  1143. ClearDisp()
  1144. {
  1145.     register int i;
  1146.  
  1147.     CursorV = 0;        /* clear the display buffer */
  1148.     CursorH = 0;
  1149.     for (i = 0; i < TermV; i++)
  1150.     Display[i][0] = '\0';
  1151.     OldvcV = 0;
  1152. }
  1153.  
  1154. void
  1155. ClearLines()
  1156. {                /* Make sure all lines are *really* blank */
  1157.     register int i;
  1158.  
  1159.     if (T_CanCEOL) {
  1160.     MoveToChar(0);
  1161.     for (i = 0; i <= OldvcV; i++) {    /* for each line on the screen */
  1162.         MoveToLine(i);
  1163.         ClearEOL(TermH);
  1164.     }
  1165.     MoveToLine(0);
  1166.     }
  1167.     else {
  1168.     MoveToLine(OldvcV);    /* go to last line */
  1169.     (void) putraw('\r');    /* go to BOL */
  1170.     (void) putraw('\n');    /* go to new line */
  1171.     }
  1172. }
  1173.